Histopathologic Cancer Detection

1. Problem & Data Description

Problem Overview

This project is based on the Histopathologic Cancer Detection competition hosted on Kaggle. The goal is to build a binary image classification model that can detect metastatic cancer in small image patches extracted from digital pathology scans. Each patch corresponds to a specific region of a lymph node biopsy and is labeled as either:

• 1: Cancerous (tumor present)
• 0: Non-cancerous (no tumor)

Detecting metastatic tissue is critical in cancer diagnosis and treatment. By automating this process with a deep learning model, we aim to support medical professionals, improve diagnostic speed, and reduce human error.

Data Description

Dataset Structure

• Image size: 96×96 pixels
• Color channels: 3 (RGB)
• File format: .tif
• Training labels: Provided in train_labels.csv:
  • id: The filename of the image (without .tif)
  • label: 0 (non-cancerous) or 1 (cancerous)

Dataset Composition

• Training set: ~220,000 labeled images
• Test set: Unlabeled images for submission
• The dataset is imbalanced, with fewer cancerous images compared to non-cancerous ones.

Machine Learning Type

• Type: Binary classification
• Modality: Image data (Computer Vision)
• Goal: Build a deep learning model (e.g., CNN or transfer learning) that outputs a binary prediction per image.

2. Exploratory Data Analysis (EDA)

Loading necessary libraries and tools

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import os
import random
import torch
import copy
import torch.nn as nn
import torch.optim as optim


from PIL import Image
from torchvision import transforms, models
from torch.utils.data import Dataset, DataLoader, WeightedRandomSampler
from sklearn.model_selection import train_test_split
from torchvision.models import resnet50, ResNet50_Weights
from torch.optim import Adam
from torch.optim.lr_scheduler import StepLR, CosineAnnealingLR
from sklearn.metrics import roc_auc_score
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torch.cuda.amp import autocast, GradScaler

2.1 Load and View Data Labels

import random, numpy as np, torch
random.seed(42)
np.random.seed(42)
torch.manual_seed(42)
if torch.cuda.is_available():
    torch.cuda.manual_seed_all(42)

# 1) Point to data folder
DATA_DIR = "/kaggle/input/histopathologic-cancer-detection"
LABELS_CSV = os.path.join(DATA_DIR, "train_labels.csv")

# 2) Load and peek at labels
labels_df = pd.read_csv(os.path.join(DATA_DIR, "train_labels.csv"))
# Display basic info
print("First 5 rows:")
display(labels_df.head())

print("\nDataset shape:", labels_df.shape)

# Check for missing values
print("\nMissing values:\n", labels_df.isnull().sum())

# View class distribution
print("\nClass distribution:")
print(labels_df['label'].value_counts())

counts = labels_df['label'].value_counts().sort_index()
plt.figure(figsize=(6,4))
plt.bar(counts.index.astype(str), counts.values)
plt.xlabel("Label")
plt.ylabel("Number of Images")
plt.title("Class Balance (0 = Negative, 1 = Cancer)")
plt.show()

First 5 rows:

	id	label
0	f38a6374c348f90b587e046aac6079959adf3835	0
1	c18f2d887b7ae4f6742ee445113fa1aef383ed77	1
2	755db6279dae599ebb4d39a9123cce439965282d	0
3	bc3f0c64fb968ff4a8bd33af6971ecae77c75e08	0
4	068aba587a4950175d04c680d38943fd488d6a9d	0

Dataset shape: (220025, 2)

Missing values:
 id       0
label    0
dtype: int64

Class distribution:
label
0    130908
1     89117
Name: count, dtype: int64

Observations

Dataset Overview

• The dataset consists of 220,025 labeled image patches, each identified by a unique ID.
• Each image is labeled with either:
  • 0: Non-cancerous (no tumor)
  • 1: Cancerous (presence of tumor)

Missing Values Check

• There are no missing values in either the id or label columns, confirming data completeness.

Class Distribution

• The class distribution is highly imbalanced:
  • 130,908 images are labeled as 0 (non-cancerous)
  • 89,117 images are labeled as 1 (cancerous)

This imbalance needs to be addressed during model training through techniques like:

• Class weighting
• Oversampling the minority class
• Data augmentation on positive samples

The next step will be to visualize and explore the image data to gain a better understanding of the content and variation within each class.

2.2 Visualize Image Samples

2.2.1 Sample Image Patches

TRAIN_DIR = os.path.join(DATA_DIR, "train")

# show 5 examples of each class
fig, axes = plt.subplots(2, 5, figsize=(15,6))
for row, label in enumerate([0, 1]):
    sample_ids = labels_df[labels_df.label==label].sample(5, random_state=0)['id']
    for col, img_id in enumerate(sample_ids):
        # try common extensions
        for ext in (".tif", ".jpg", ".png"):
            path = os.path.join(TRAIN_DIR, img_id + ext)
            if os.path.exists(path):
                img = Image.open(path)
                break
        axes[row, col].imshow(img)
        axes[row, col].axis("off")
        if col == 2:
            axes[row, col].set_title(f"Label = {label}", fontsize=14)
plt.tight_layout()
plt.show()

Observations:

We visualized 5 random samples each from the two classes:

• Negative (Label = 0):
  • Generally looser tissue, more whitespace between nuclei.
  • Lighter staining in some regions; less cellular crowding.
• Positive (Label = 1):
  • Denser, more irregular cell clusters.
  • Darker, more homogeneous staining in the center (where metastases lie).

The two classes differ both in texture (cell density) and color intensity. Our model will need to learn both shape and color cues, so we should preserve as much of that variation as possible in preprocessing.

2.2.2 Pixel‐Value Histograms

sample_paths = random.sample(os.listdir(TRAIN_DIR), 500)
reds = []
for fname in sample_paths:
    img = np.array(Image.open(os.path.join(TRAIN_DIR, fname)))
    reds.extend(img[:,:,0].ravel())
plt.hist(reds, bins=50)
plt.title("Red‐Channel Intensity Distribution (random 500 patches)")
plt.xlabel("Pixel value")
plt.ylabel("Count")
plt.show()

Plot above shows the distribution of red-channel pixel intensities from a random sample of 500 image patches.

Observations:

• The red‐channel intensities skew high (200–255), with a heavy tail near pure white.
• There’s a wide dynamic range from near‐0 (dark) up to 255 (bright pink/purple).

We should normalize each channel (e.g. to [0, 1], then standardize by channel mean/std) so that the network sees zero‐centered inputs. We may also consider stain‐normalization techniques (e.g. Macenko) or simple color‐jitter to make the model robust to slide‐to‐slide staining variation.

2.3 Preprocessing & Data Pipeline

To prepare the data for modeling, we will:

1. Resize / Reformat

   • Images are already 96 × 96, so no resizing needed for a scratch-built CNN.
   • If use a pretrained model (e.g. ResNet, EfficientNet), up-sample to its expected input size (e.g. 224×224).

2. Normalize Pixel Values

   • Scale each channel to [0, 1].
   • Compute per-channel mean and standard deviation on the training set; subtract the mean and divide by the std.
   • (Optional) Apply stain-normalization (e.g. Macenko) if there’s noticeable color drift between slides.

3. Augment Data

   • Spatial: random flips, small rotations (±15°), random zooms/crops.
   • Color: brightness/contrast jitter, hue/saturation jitter.
   • To address the ~60/40 class imbalance, either oversample the minority class (label=1) in your loader or apply class-weighted loss.

4. Create Train/Validation Split

   • Perform an 80/20 stratified split so both subsets maintain the original class ratio.
   • Use the validation set for early stopping and hyperparameter tuning.

5. Build Data Loaders

   • In PyTorch: implement a Dataset that reads IDs → loads images and labels → applies transforms → returns tensors; wrap in a DataLoader (with WeightedRandomSampler if oversampling).
   • In TensorFlow: build a tf.data.Dataset from filenames and labels → map to decode & preprocess functions → batch, shuffle, and prefetch.

Once that’s in place, we’ll move on to Section 3: implementing our baseline CNN and a transfer‐learning approach.

2.3.1 Resize / Reformat

• Goal: ensure all images match the input size your model expects
• Scratch CNN: we can keep 96×96
• Pretrained backbone: typically 224×224, 256×256, etc.

# 1) Paths
DATA_DIR = "/kaggle/input/histopathologic-cancer-detection"
TRAIN_DIR = os.path.join(DATA_DIR, "train")
CSV_PATH  = os.path.join(DATA_DIR, "train_labels.csv")

# 2) Create a proper train/val split
train_df, val_df = train_test_split(
    labels_df,
    test_size=0.2,
    stratify=labels_df['label'],
    random_state=42
)
print("Train / Val shapes:", train_df.shape, val_df.shape)

Train / Val shapes: (176020, 2) (44005, 2)

# 3) Define resize transform
INPUT_SIZE = 224
resize_and_tensor = transforms.Compose([
    transforms.Resize((INPUT_SIZE, INPUT_SIZE)),
    transforms.ToTensor(),
])

# 4) Dataset class
class HistopathDataset(Dataset):
    def __init__(self, df, image_dir, transform=None):
        self.df = df.reset_index(drop=True)
        self.image_dir = image_dir
        self.transform = transform

    def __len__(self):
        return len(self.df)

    def __getitem__(self, idx):
        row = self.df.iloc[idx]
        # look for .tif or .jpg
        for ext in (".tif", ".jpg"):
            path = os.path.join(self.image_dir, row.id + ext)
            if os.path.exists(path):
                img = Image.open(path)
                break
        if self.transform:
            img = self.transform(img)
        return img, row.label

# 5) Create DataLoader
train_ds     = HistopathDataset(train_df, TRAIN_DIR, transform=resize_and_tensor)
train_loader = DataLoader(train_ds, batch_size=64, shuffle=True, num_workers=4)

# 6) sanity check
small_df = train_df.sample(1000, random_state=0)
small_ds = HistopathDataset(small_df, TRAIN_DIR, transform=resize_and_tensor)
small_loader = DataLoader(small_ds, batch_size=64, shuffle=True, num_workers=0)
imgs_s, labels_s = next(iter(small_loader))
print("Small batch shapes:", imgs_s.shape, labels_s.shape)

Small batch shapes: torch.Size([64, 3, 224, 224]) torch.Size([64])

2.3.2 Normalize Pixel Values

1. Compute per‐channel mean & std on the training set.

2. Add a Normalize step to the transform.

a) Compute Mean & Std

# Helper: get a few batches to estimate statistics
loader_for_stats = DataLoader(
    HistopathDataset(train_df.sample(5000, random_state=0), TRAIN_DIR,
                     transform=transforms.Compose([
                         transforms.Resize((INPUT_SIZE, INPUT_SIZE)),
                         transforms.ToTensor(),
                     ])),
    batch_size=64,
    shuffle=False,
    num_workers=0
)

# Accumulators
sum_channels = torch.zeros(3)
sum_sq_channels = torch.zeros(3)
n_pixels = 0

for imgs, _ in loader_for_stats:
    # imgs shape: [B, 3, H, W]
    B, C, H, W = imgs.shape
    imgs = imgs.view(B, C, -1)  # [B, 3, H*W]
    sum_channels += imgs.sum(dim=(0, 2))
    sum_sq_channels += (imgs ** 2).sum(dim=(0, 2))
    n_pixels += B * H * W

# Final mean & std
mean = sum_channels / n_pixels
std  = torch.sqrt(sum_sq_channels / n_pixels - mean**2)

print("Estimated mean:", mean)
print("Estimated std: ", std)

Estimated mean: tensor([0.6999, 0.5416, 0.6931])
Estimated std:  tensor([0.2213, 0.2659, 0.1982])

Observations

• Estimated per‐channel means:
  • Red ≈ 0.70
  • Green ≈ 0.54
  • Blue ≈ 0.69
• Estimated per‐channel stds:
  • Red ≈ 0.22
  • Green ≈ 0.27
  • Blue ≈ 0.20

These will be used in our Normalize(mean, std) step so that each channel is zero‐centered with unit variance.

b) Update the Transform

# ✏️ Set the values from step a above
MEAN = [0.6999, 0.5416, 0.6931]
STD  = [0.2213, 0.2659, 0.1982]

resize_normalize = transforms.Compose([
    transforms.Resize((INPUT_SIZE, INPUT_SIZE)),
    transforms.ToTensor(),
    transforms.Normalize(mean=MEAN, std=STD),
])

# 2) Build a small Dataset + Loader for debugging
small_ds_norm    = HistopathDataset(small_df, TRAIN_DIR, transform=resize_normalize)
small_loader_norm = DataLoader(small_ds_norm, batch_size=64, shuffle=True, num_workers=0)

# 3) Pull one small batch and check
imgs_sn, labels_sn = next(iter(small_loader_norm))
print("Small normalized batch:", imgs_sn.shape, labels_sn.shape)
print("  mean:", imgs_sn.mean(dim=[0,2,3]), 
      " std:", imgs_sn.std(dim=[0,2,3]))

Small normalized batch: torch.Size([64, 3, 224, 224]) torch.Size([64])
  mean: tensor([-0.0362, -0.0636, -0.0779])  std: tensor([0.9963, 0.9786, 1.0253])

Observations

• Sanity check batch shape: 64 × 3 × 224 × 224 (64 images, 3 channels, 224×224 pixels)
• Per-channel mean (after Normalize):
  • Red ≈ –0.036
  • Green ≈ –0.064
  • Blue ≈ –0.078
• Per-channel std (after Normalize):
  • Red ≈ 0.996
  • Green ≈ 0.979
  • Blue ≈ 1.025

These are very close to zero‐mean and unit‐variance as intended. The slight deviations (especially the blue channel being ~1.025) are expected with our 1 000-sample debug set and will average out when we train on the full dataset.

2.3.3 Data Augmentation

Next, we’ll enrich our training set with spatial and color transforms to improve generalization.

augment_and_norm = transforms.Compose([
    transforms.Resize((INPUT_SIZE, INPUT_SIZE)),
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(degrees=15),
    transforms.RandomResizedCrop(INPUT_SIZE, scale=(0.8, 1.0)),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.1),
    transforms.ToTensor(),
    transforms.Normalize(mean=MEAN, std=STD),
])

# Small‐sample debug loader
small_aug_ds   = HistopathDataset(small_df, TRAIN_DIR, transform=augment_and_norm)
small_aug_ldr  = DataLoader(small_aug_ds, batch_size=16, shuffle=True, num_workers=0)

# grab a single batch
imgs_batch, _ = next(iter(small_aug_ldr))   # imgs_batch.shape == [16,3,224,224]

fig, axs = plt.subplots(2, 4, figsize=(12,6))
for i, ax in enumerate(axs.flatten()):
    img = imgs_batch[i]                     # now img.shape == [3,224,224]
    # un-normalize
    img = img * torch.tensor(STD).view(3,1,1) \
          + torch.tensor(MEAN).view(3,1,1)
    img = img.clamp(0,1)
    ax.imshow(img.permute(1,2,0).cpu().numpy())
    ax.axis("off")

plt.suptitle("Augmented Samples")
plt.show()

Observations

• Random Rotations & Crops
  • Many patches are shown at odd angles, with black triangular borders where the image was rotated and then resized/cropped.
• Horizontal Flips
  • Some tissue patterns appear mirrored left-to-right, confirming flips are applied with ~50% probability.
• Color Jitter Effects
  • Noticeable brightness and contrast shifts: a few patches have deeper purple hues, while others look washed-out or warmer pink.
  • Slight hue variation is visible in the connective tissue regions.
• Morphology Preservation
  • Despite the aggressive transforms, cellular structures remain intact—nuclei and tissue boundaries are still clear.

Overall, the combination of spatial (rotation, resized crop, flip) and color (jitter) augmentations is producing a diverse set of realistic-looking patches without corrupting key histological features.

2.3.4 Create Train / Validation DataLoaders

Now that we have our transforms defined, we’ll build two separate DataLoaders:

• Train loader

  • Uses augment_and_norm for on-the-fly augmentation + normalization
  • Shuffles each epoch
  • Uses a WeightedRandomSampler to counter the ~60/40 class imbalance

• Validation loader

  • Uses resize_normalize (no randomness)
  • No shuffling, to get a stable performance estimate

# set a debugging set
debug_df = small_df            # switch this back train_df when training
debug_val_df = val_df.sample(200, random_state=0)  # switch back to val_df when training

# 1) Training dataset + sampler
train_ds = HistopathDataset(debug_df, TRAIN_DIR, transform=augment_and_norm) #switch back to train_df when training

# Compute weights: inverse of class frequency
class_counts   = debug_df['label'].value_counts().to_dict()   #switch back to train_df when training
class_weights  = {lbl: 1.0/count for lbl, count in class_counts.items()}
sample_weights = debug_df['label'].map(class_weights).values
sampler        = WeightedRandomSampler(
    weights=sample_weights,
    num_samples=len(sample_weights),
    replacement=True
)

train_loader = DataLoader(
    train_ds,
    batch_size=32, # change to 64 when training
    sampler=sampler,
    num_workers=0  # change to 2 first and 3,4 see how computer handles
)

# 2) Validation dataset + loader
val_ds = HistopathDataset(debug_val_df, TRAIN_DIR, transform=resize_normalize) #switch back to var_df when training
val_loader = DataLoader(
    val_ds,
    batch_size=32, # change to 64 when training
    shuffle=False,
    num_workers=0 # change to 2 first and 3,4 see how computer handles
)

# 3) Quick sanity check
imgs_tr, lbls_tr = next(iter(train_loader))
imgs_val, lbls_val = next(iter(val_loader))
print("Train batch:", imgs_tr.shape, lbls_tr.shape)
print("Val batch:  ", imgs_val.shape, lbls_val.shape)

Train batch: torch.Size([32, 3, 224, 224]) torch.Size([32])
Val batch:   torch.Size([32, 3, 224, 224]) torch.Size([32])

• Train loader batch shape: ([32, 3, 224, 224], [32])
• Val loader batch shape: ([32, 3, 224, 224], [32])
• Both loaders are wired up as intended, ready for model training.

3. Model Architecture

Below we describe two complementary approaches: a small from-scratch CNN to establish a baseline, and a transfer-learning setup leveraging a pretrained backbone to accelerate convergence and boost accuracy on limited data.

3.1 Baseline CNN

We build a lightweight 3-block convolutional network that progressively abstracts spatial features:

1. Input

   • 3 color channels (RGB)
   • Spatial size: 224×224 pixels (after our resize)

2. Conv Block 1

   • Conv2d(3 → 32, 3×3, padding=1): learns 32 low-level filters (edges, simple color blobs)
   • BatchNorm2d(32): stabilizes training by normalizing each mini-batch
   • ReLU: injects nonlinearity
   • MaxPool2d(2): downsamples by 2×, output → 32×112×112

3. Conv Block 2

   • Conv2d(32 → 64, 3×3, padding=1): learns 64 mid-level filters (corners, texture patterns)
   • BatchNorm2d(64) + ReLU
   • MaxPool2d(2): now 64×56×56

4. Conv Block 3

   • Conv2d(64 → 128, 3×3, padding=1): learns 128 high-level filters (complex shapes, clusters)
   • BatchNorm2d(128) + ReLU
   • MaxPool2d(2): now 128×28×28

5. Classifier Head

   • Flatten: collapses spatial dims → vector of length 128·28·28
   • Dropout(0.5): regularizes by randomly zeroing features
   • Linear(128·28·28 → 256) + ReLU + Dropout(0.5)
   • Linear(256 → 1) + Sigmoid: outputs probability of metastatic tissue

Why this design?

• Each block doubles filters while halving spatial size—standard in CNNs to capture increasing abstraction.
• BatchNorm + ReLU speeds up convergence and combats internal covariate shift.
• Two dense layers with dropout help the network combine features into a robust decision.

---

class BaselineCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            # Block 1
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),            # 32×112×112

            # Block 2
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),            # 64×56×56

            # Block 3
            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),            # 128×28×28
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Dropout(0.5),
            nn.Linear(128 * 28 * 28, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(256, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

# Instantiate
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
baseline_model = BaselineCNN().to(device)
print(baseline_model)

BaselineCNN(
  (features): Sequential(
    (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (1): BatchNorm2d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (2): ReLU(inplace=True)
    (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (4): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (5): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (6): ReLU(inplace=True)
    (7): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
    (8): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (9): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (10): ReLU(inplace=True)
    (11): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (classifier): Sequential(
    (0): Flatten(start_dim=1, end_dim=-1)
    (1): Dropout(p=0.5, inplace=False)
    (2): Linear(in_features=100352, out_features=256, bias=True)
    (3): ReLU(inplace=True)
    (4): Dropout(p=0.5, inplace=False)
    (5): Linear(in_features=256, out_features=1, bias=True)
    (6): Sigmoid()
  )
)

Observations

• Architecture matches our design:
  • Three convolutional blocks, each doing:
    1. A 3×3 convolution (padding=1 to preserve spatial size)
    2. BatchNorm + ReLU
    3. 2×2 max‐pool (halves H×W from 224→112→56→28)
  • Filter counts double each block: 3→32→64→128.
• Flatten dimension:
  • After Block 3 the feature map is 128×28×28 → 128·28·28 = 100 352 features, which feeds into our 256-unit dense layer.
• Parameter count:
  • The bulk of parameters lives in the dense layers (~25.7 M for the 100 352→256 mapping), with the conv layers contributing a few tens of thousands.

3.2 Transfer Learning

Here we leverage a heavy‐duty pretrained network (ResNet50) that has already learned powerful image-recognition filters from ImageNet:

1. Backbone: ResNet50

   • 50 layers deep, built from residual blocks that ease gradient flow
   • Pretrained on millions of natural images, so early filters detect universal edges, textures, shapes

2. Freezing Strategy

   • Freeze all convolutional weights initially → only train the final classification head
   • This reduces overfitting and speeds up training on our small dataset

3. Classification Head Replacement

   • Remove the original fc layer of ResNet50
   • Add:

     nn.Linear(in_features, 1)
     nn.Sigmoid()
     

   • in_features matches the backbone’s penultimate feature dimension (usually 2048)

4. Fine-tuning Option

   • After a few epochs, unfreeze the last residual block(s) and train with a lower learning rate
   • Allows the model to adapt high-level filters to histopathology textures

Why this design?

• Pretrained filters give a head start on low- and mid-level pattern recognition.
• Freezing reduces computational cost and overfitting risk.
• Fine-tuning later can further tailor the network to our specialized domain.

# —— 3.2 Transfer Learning with ResNet50 (updated weights API) —— 
if os.path.exists("/kaggle/input/resnet50-pth-weights/resnet50-0676ba61.pth"):
    tl_model = resnet50(weights=None)
    tl_model.load_state_dict(torch.load("/kaggle/input/resnet50-pth-weights/resnet50-0676ba61.pth", weights_only=True))
else:
    weights = ResNet50_Weights.IMAGENET1K_V1
    tl_model = resnet50(weights=weights)

base_state_dict = tl_model.state_dict()

# 1) Select pretrained weights enum
# weights = ResNet50_Weights.IMAGENET1K_V1

# 2) Load the model with those weights
# tl_model = resnet50(weights=weights)

# 3) Freeze all convolutional parameters
for param in tl_model.parameters():
    param.requires_grad = False

# 4) Replace the final fully-connected head for binary output
in_features = tl_model.fc.in_features
tl_model.fc = nn.Sequential(
    nn.Linear(in_features, 1),
    nn.Sigmoid()
)

# 5) Move to GPU and inspect the new head
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
tl_model = tl_model.to(device)

print("New classification head:", tl_model.fc)

New classification head: Sequential(
  (0): Linear(in_features=2048, out_features=1, bias=True)
  (1): Sigmoid()
)

Observations

• Classification head correctly replaced:

  • The new head is

    Sequential(
      (0): Linear(in_features=2048, out_features=1, bias=True)
      (1): Sigmoid()
    )
    

  • Only ~2 049 trainable parameters here (2048 weights + 1 bias), versus ~25 M in the full backbone.

• Backbone frozen:

  • All earlier ResNet50 layers have requires_grad=False, so only the new head will update on early epochs.
  • This minimizes overfitting risk and speeds up initial training.

• Ready for fine-tuning:

  • Once the head has converged, we can unfreeze the last residual block(s) and continue training with a lower learning rate to further adapt high-level features to histopathology.

3.3 Training & Hyperparameter Setup

Goal: Define our loss, optimizers, schedulers, and training loop so we can train both the BaselineCNN and the Transfer‐Learning model.

Outline

1. Loss Function

   • Use binary cross‐entropy (BCELoss) since our models output a probability.

2. Optimizers

   • BaselineCNN: train all parameters with Adam (e.g. lr=1e-4).
   • Transfer‐Learning: train only the head (tl_model.fc) with a higher lr (e.g. 1e-3), backbone frozen initially.

3. Learning‐Rate Scheduler

   • E.g. StepLR or ReduceLROnPlateau to decay lr over time.

4. Training & Validation Functions

   • train_one_epoch()
   • validate()

5. Metrics & Checkpointing

   • Track loss and ROC‐AUC.
   • Save the best model by validation AUC.

# 1) Loss
criterion = nn.BCELoss()

# 2) Optimizers & Schedulers
optimizer_base = Adam(baseline_model.parameters(), lr=1e-4)
scheduler_base = StepLR(optimizer_base, step_size=5, gamma=0.5)

optimizer_tl   = Adam(tl_model.fc.parameters(), lr=1e-3)
scheduler_tl   = StepLR(optimizer_tl, step_size=3, gamma=0.2)

# 3) Training / Validation loops
def train_one_epoch(model, loader, criterion, optimizer, device):
    model.train()
    running_loss, preds, trues = 0.0, [], []
    for imgs, labels in loader:
        imgs, labels = imgs.to(device), labels.float().to(device)
        optimizer.zero_grad()
        outputs = model(imgs).view(-1)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item() * imgs.size(0)
        preds += outputs.detach().cpu().tolist()
        trues += labels.detach().cpu().tolist()
    epoch_loss = running_loss / len(loader.dataset)
    epoch_auc  = roc_auc_score(trues, preds)
    return epoch_loss, epoch_auc

def validate(model, loader, criterion, device):
    model.eval()
    running_loss, preds, trues = 0.0, [], []
    with torch.no_grad():
        for imgs, labels in loader:
            imgs, labels = imgs.to(device), labels.float().to(device)
            outputs = model(imgs).view(-1)
            running_loss += criterion(outputs, labels).item() * imgs.size(0)
            preds += outputs.cpu().tolist()
            trues += labels.cpu().tolist()
    epoch_loss = running_loss / len(loader.dataset)
    epoch_auc  = roc_auc_score(trues, preds)
    return epoch_loss, epoch_auc

# 4) Full training loop
def fit_model(model, train_loader, val_loader, optimizer, scheduler, device, epochs=10, prefix="model"):
    best_auc = 0.0
    for ep in range(1, epochs+1):
        train_loss, train_auc = train_one_epoch(model, train_loader, criterion, optimizer, device)
        val_loss, val_auc     = validate(model, val_loader, criterion, device)
        scheduler.step()
        print(f"{prefix} Epoch {ep}/{epochs} "
              f"→ train_loss {train_loss:.4f}, train_auc {train_auc:.4f} | "
              f"val_loss {val_loss:.4f}, val_auc {val_auc:.4f}")
        if val_auc > best_auc:
            best_auc = val_auc
            torch.save(model.state_dict(), f"best_{prefix}.pt")
    print(f"Best {prefix} val_auc: {best_auc:.4f}")

# 5) Run experiments
print("Training BaselineCNN…")
fit_model(baseline_model, train_loader, val_loader, optimizer_base, scheduler_base, device, epochs=10, prefix="baseline")

print("\nTraining Transfer‐Learning model…")
fit_model(tl_model,     train_loader, val_loader, optimizer_tl,   scheduler_tl,   device, epochs=5,  prefix="resnet50_head")

Training BaselineCNN…
baseline Epoch 1/10 → train_loss 1.2011, train_auc 0.6070 | val_loss 0.6199, val_auc 0.8259
baseline Epoch 2/10 → train_loss 0.6573, train_auc 0.7043 | val_loss 0.5025, val_auc 0.8535
baseline Epoch 3/10 → train_loss 0.5701, train_auc 0.7831 | val_loss 0.4956, val_auc 0.8627
baseline Epoch 4/10 → train_loss 0.5646, train_auc 0.7939 | val_loss 0.5458, val_auc 0.7999
baseline Epoch 5/10 → train_loss 0.5890, train_auc 0.7694 | val_loss 0.4899, val_auc 0.8479
baseline Epoch 6/10 → train_loss 0.5582, train_auc 0.7883 | val_loss 0.5059, val_auc 0.8427
baseline Epoch 7/10 → train_loss 0.5354, train_auc 0.8121 | val_loss 0.4838, val_auc 0.8488
baseline Epoch 8/10 → train_loss 0.5665, train_auc 0.7927 | val_loss 0.5116, val_auc 0.8413
baseline Epoch 9/10 → train_loss 0.5171, train_auc 0.8259 | val_loss 0.4954, val_auc 0.8347
baseline Epoch 10/10 → train_loss 0.5429, train_auc 0.8075 | val_loss 0.4986, val_auc 0.8512
Best baseline val_auc: 0.8627

Training Transfer‐Learning model…
resnet50_head Epoch 1/5 → train_loss 0.5543, train_auc 0.8315 | val_loss 0.4946, val_auc 0.8789
resnet50_head Epoch 2/5 → train_loss 0.4889, train_auc 0.8456 | val_loss 0.4405, val_auc 0.8916
resnet50_head Epoch 3/5 → train_loss 0.4638, train_auc 0.8641 | val_loss 0.4274, val_auc 0.8982
resnet50_head Epoch 4/5 → train_loss 0.4387, train_auc 0.8795 | val_loss 0.4232, val_auc 0.9009
resnet50_head Epoch 5/5 → train_loss 0.4358, train_auc 0.8819 | val_loss 0.4238, val_auc 0.9008
Best resnet50_head val_auc: 0.9009

---

3.4 Training Results & Comparison

Here are the updated results from our debug runs:

Model	Final Train Loss	Final Train AUC	Final Val Loss	Final Val AUC	Best Val AUC
BaselineCNN	0.5429	0.8075	0.4986	0.8512	0.8627
ResNet50 (head)	0.4358	0.8819	0.4238	0.9008	0.9009

• BaselineCNN learned steadily over 10 epochs but plateaued around 0.86 val AUC.
• ResNet50 head again outperformed the baseline, reaching ~0.90 val AUC by epoch 4 and peaking at 0.9009.
• The gap (~0.04 AUC) underscores the benefit of transfer learning for our histopathology patches.

3.5 Hyperparameter Tuning & Fine-Tuning

Now, We’ll explore two key adjustments to boost our Transfer-Learning model:

1. Unfreeze high-level backbone layers

   • Allow the last ResNet block (layer4) to update so that domain-specific features can adapt.
   • Use a smaller LR for backbone vs. head to avoid destroying pretrained weights.

2. Add weight decay

   • Regularizes both head and unfrozen backbone parameters to combat overfitting.

3. Switch to ReduceLROnPlateau

   • Dynamically reduces LR when validation AUC plateaus.

3.5.1 Fine-Tune the Last ResNet Block

# 1) Unfreeze layer4
for param in tl_model.layer4.parameters():
    param.requires_grad = True

# 2) Define a two-LR optimizer with weight decay
optimizer_ft = optim.Adam([
    {'params': tl_model.fc.parameters(),     'lr': 1e-4},
    {'params': tl_model.layer4.parameters(), 'lr': 1e-5}
], weight_decay=1e-4)

# 3) ReduceLROnPlateau (without verbose)
scheduler_ft = ReduceLROnPlateau(
    optimizer_ft,
    mode='max',
    factor=0.5,
    patience=2
)

# 4) Retrain for a few more epochs on debug set
print("Fine-tuning ResNet50 layer4 + head…")
for ep in range(1, 6):
    train_loss, train_auc = train_one_epoch(
        tl_model, train_loader, criterion, optimizer_ft, device
    )
    val_loss, val_auc = validate(
        tl_model, val_loader, criterion, device
    )
    scheduler_ft.step(val_auc)  # monitor val AUC
    print(f"FT Epoch {ep}/5 → "
          f"train_loss {train_loss:.4f}, train_auc {train_auc:.4f} | "
          f"val_loss {val_loss:.4f}, val_auc {val_auc:.4f}")

Fine-tuning ResNet50 layer4 + head…
FT Epoch 1/5 → train_loss 0.4336, train_auc 0.8820 | val_loss 0.3926, val_auc 0.9115
FT Epoch 2/5 → train_loss 0.4214, train_auc 0.8840 | val_loss 0.3691, val_auc 0.9222
FT Epoch 3/5 → train_loss 0.4101, train_auc 0.8925 | val_loss 0.3532, val_auc 0.9319
FT Epoch 4/5 → train_loss 0.3831, train_auc 0.9110 | val_loss 0.3897, val_auc 0.9211
FT Epoch 5/5 → train_loss 0.3311, train_auc 0.9349 | val_loss 0.3605, val_auc 0.9195

Observations

• Val AUC progression during layer4 fine-tuning:

  1. Epoch 1 → val_auc = 0.9115
  2. Epoch 2 → val_auc = 0.9222
  3. Epoch 3 → peak val_auc = 0.9319
  4. Epoch 4 → val_auc = 0.9211
  5. Epoch 5 → val_auc = 0.9195

• Training AUC climbs steadily to ~0.935 by epoch 5, indicating the model is still fitting harder.

• Overfitting signal: val_auc drops after epoch 3 despite training_auc rising, so we should consider early stopping around epoch 3 on the debug set.

• Next action:

  • Freeze in this early-stop regime (3 epochs) when running on full data.
  • Move forward with weight_decay=1e-3 and CosineAnnealingLR as before.

3.5.2 Weight Decay Sweep

We’ll experiment with three weight‐decay values to see which regularization strength best preserves our peak val AUC:

• Candidates: [1e-5, 1e-4, 1e-3]
• Protocol:
  1. Unfreeze only layer4 + head (as before).
  2. Train for 3 epochs on the debug set.
  3. Record the best validation AUC.

weight_decays = [1e-5, 1e-4, 1e-3]
wd_results = {}

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

for wd in weight_decays:
    # 1) Reset a fresh model
    model = resnet50(weights=None)
    model.load_state_dict(base_state_dict)
    
    for p in model.parameters(): 
        p.requires_grad = False
    # replace head
    in_f = model.fc.in_features
    model.fc = nn.Sequential(nn.Linear(in_f,1), nn.Sigmoid())
    # unfreeze layer4
    for p in model.layer4.parameters(): 
        p.requires_grad = True
    model = model.to(device)

    # 2) Optimizer & Cosine scheduler (3-epoch cycle)
    optimizer = optim.Adam([
        {'params': model.fc.parameters(),     'lr': 1e-4},
        {'params': model.layer4.parameters(), 'lr': 1e-5}
    ], weight_decay=wd)
    scheduler = CosineAnnealingLR(optimizer, T_max=3)

    # 3) Run 3 epochs, track best AUC
    best_auc = 0.0
    for epoch in range(1, 4):
        _, train_auc = train_one_epoch(model, train_loader, criterion, optimizer, device)
        _, val_auc   = validate(model,     val_loader,   criterion, device)
        scheduler.step()
        best_auc = max(best_auc, val_auc)

    wd_results[wd] = best_auc
    print(f"Weight decay {wd:>7} → Best Val AUC = {best_auc:.4f}")

print("\nSweep results:", wd_results)

Weight decay   1e-05 → Best Val AUC = 0.8886
Weight decay  0.0001 → Best Val AUC = 0.8907
Weight decay   0.001 → Best Val AUC = 0.8764

Sweep results: {1e-05: 0.888617638083613, 0.0001: 0.8906520191231817, 0.001: 0.8764113518462008}

Observations

• Weight-decay sweep results (debug set):
  | Weight decay | Best Val AUC | |-------------:|-------------:| | 1e-5 | 0.8886 | | 1e-4 | 0.8907 | | 1e-3 | 0.8764 |

• Best regularization on our small debug slice is 1e-4, so we should use that going forward.

3.5.3 Scheduler Sweep

With weight_decay=1e-4 in place, you’ll confirm once more that CosineAnnealingLR still outperforms StepLR before moving on to the full-data run.

scheduler_factories = {
    "StepLR":           lambda opt: StepLR(opt,           step_size=3, gamma=0.5),
    "CosineAnnealingLR":lambda opt: CosineAnnealingLR(opt, T_max=5)
}

results = {}
for name, make_scheduler in scheduler_factories.items():
    # 1) Fresh model + layer4 only unfrozen
    model = resnet50(weights=None)
    model.load_state_dict(base_state_dict)
    for p in model.parameters(): p.requires_grad = False
    in_f = model.fc.in_features
    model.fc = nn.Sequential(nn.Linear(in_f,1), nn.Sigmoid())
    for p in model.layer4.parameters(): p.requires_grad = True
    model = model.to(device)

    # 2) Optimizer with WD=1e-4
    optimizer = optim.Adam([
        {'params': model.fc.parameters(),     'lr': 1e-4},
        {'params': model.layer4.parameters(), 'lr': 1e-5}
    ], weight_decay=1e-4)

    # 3) Attach scheduler
    scheduler = make_scheduler(optimizer)

    # 4) Train 3 epochs & track best AUC
    best_auc = 0.0
    for _ in range(3):
        _, _      = train_one_epoch(model, train_loader, criterion, optimizer, device)
        _, val_auc= validate(model,      val_loader,   criterion, device)
        scheduler.step()      # same API for both schedulers
        best_auc = max(best_auc, val_auc)

    results[name] = best_auc
    print(f"{name}: Best Val AUC = {best_auc:.4f}")

print("\nScheduler sweep results:", results)

StepLR: Best Val AUC = 0.8995
CosineAnnealingLR: Best Val AUC = 0.9051

Scheduler sweep results: {'StepLR': 0.8995015766453057, 'CosineAnnealingLR': 0.9050961245041196}

Observations

• StepLR (step_size=3, γ=0.5) → Best Val AUC = 0.8995
• CosineAnnealingLR (T_max=5) → Best Val AUC = 0.9051

CosineAnnealingLR still wins by ~0.0056 AUC on the debug set, so we’ll use that scheduler going forward.

# Reserve parameters in case 3.6 stop
%store train_df
%store val_df
%store resize_normalize
%store augment_and_norm
%store device
%store INPUT_SIZE
%store MEAN
%store STD

Stored 'train_df' (DataFrame)
Stored 'val_df' (DataFrame)
Stored 'resize_normalize' (Compose)
Stored 'augment_and_norm' (Compose)
Stored 'device' (device)
Stored 'INPUT_SIZE' (int)
Stored 'MEAN' (list)
Stored 'STD' (list)

# reserve model
class HistopathDataset(torch.utils.data.Dataset):
    def __init__(self, df, image_dir, transform=None):
        self.df = df.reset_index(drop=True)
        self.image_dir = image_dir
        self.transform = transform

    def __len__(self):
        return len(self.df)

    def __getitem__(self, idx):
        row = self.df.iloc[idx]
        for ext in (".tif", ".jpg"):
            path = os.path.join(self.image_dir, row.id + ext)
            if os.path.exists(path):
                img = Image.open(path)
                break
        if self.transform:
            img = self.transform(img)
        return img, row.label

# Re-create model definitions
baseline_model = BaselineCNN().to(device)

tl_model = resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)
for p in tl_model.parameters(): p.requires_grad = False
in_feats = tl_model.fc.in_features
tl_model.fc = nn.Sequential(nn.Linear(in_feats, 1), nn.Sigmoid())
for p in tl_model.layer4.parameters(): p.requires_grad = True
tl_model = tl_model.to(device)

3.6 Full-Data Training

We now scale our best transfer-learning recipe (ResNet50 head + layer4 fine-tuning, weight_decay=1e-4, CosineAnnealingLR) to the full 80/20 split:

• Transforms
  • Train: augment_and_norm
  • Val: resize_normalize
• DataLoaders
  • batch_size=64, num_workers=4, pin_memory=True
  • Train sampler: WeightedRandomSampler for class balance
• Model
  • ResNet50 pretrained → freeze all layers except layer4 + head
• Optimizer
  • Adam head LR=1e − 4, layer4 LR=1e − 5, weight_decay=1e − 4
• Scheduler
  • CosineAnnealingLR(T_max=5)
• Early stopping
  • Stop if val AUC doesn’t improve for 2 epochs (max 15 epochs)

import time

# 1) Data paths & device
DATA_DIR  = "/kaggle/input/histopathologic-cancer-detection"
TRAIN_DIR = os.path.join(DATA_DIR, "train")
device    = torch.device("cuda" if torch.cuda.is_available() else "cpu")

# 2) Full train/val split (already in memory via %store or from Section 2)
#    train_df, val_df

# 3) Transforms (from Section 2.3)
#    resize_normalize, augment_and_norm

# 4) DataLoaders
batch_size  = 64
num_workers = 4
pin_memory  = torch.cuda.is_available()

# Weighted sampler for class balance
class_counts   = train_df['label'].value_counts().to_dict()
class_weights  = {lbl: 1.0/count for lbl, count in class_counts.items()}
sample_weights = train_df['label'].map(class_weights).values
train_sampler  = WeightedRandomSampler(
    sample_weights, num_samples=len(sample_weights), replacement=True
)

train_loader = DataLoader(
    HistopathDataset(train_df, TRAIN_DIR, transform=augment_and_norm),
    batch_size=batch_size,
    sampler=train_sampler,
    num_workers=num_workers,
    pin_memory=pin_memory
)

val_loader = DataLoader(
    HistopathDataset(val_df, TRAIN_DIR, transform=resize_normalize),
    batch_size=batch_size,
    shuffle=False,
    num_workers=num_workers,
    pin_memory=pin_memory
)

# 5) Model setup
model = resnet50(weights=None)
model.load_state_dict(base_state_dict)
for p in model.parameters():
    p.requires_grad = False
in_f = model.fc.in_features
model.fc = nn.Sequential(nn.Linear(in_f,1), nn.Sigmoid())
for p in model.layer4.parameters():
    p.requires_grad = True
model = model.to(device)

# 6) Optimizer, scheduler, loss
optimizer = optim.Adam([
    {'params': model.fc.parameters(),     'lr': 1e-4},
    {'params': model.layer4.parameters(), 'lr': 1e-5}
], weight_decay=1e-4)

scheduler = CosineAnnealingLR(optimizer, T_max=5)
criterion = nn.BCELoss()

# 7) Training & validation helpers
def train_one_epoch(model, loader):
    model.train()
    running_loss, preds, trues = 0.0, [], []
    for imgs, labels in loader:
        imgs   = imgs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True).float()
        optimizer.zero_grad()
        outputs = model(imgs).view(-1)
        loss    = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item() * imgs.size(0)
        preds += outputs.detach().cpu().tolist()
        trues += labels.detach().cpu().tolist()
    return running_loss/len(loader.dataset), roc_auc_score(trues, preds)

def validate(model, loader):
    model.eval()
    running_loss, preds, trues = 0.0, [], []
    with torch.no_grad():
        for imgs, labels in loader:
            imgs   = imgs.to(device, non_blocking=True)
            labels = labels.to(device, non_blocking=True).float()
            outputs = model(imgs).view(-1)
            running_loss += criterion(outputs, labels).item() * imgs.size(0)
            preds += outputs.cpu().tolist()
            trues += labels.cpu().tolist()
    return running_loss/len(loader.dataset), roc_auc_score(trues, preds)

# 8) Full training loop
best_auc          = 0.0
epochs_no_improve = 0
max_epochs        = 15
patience          = 2

for epoch in range(1, max_epochs+1):
    start = time.time()
    tr_loss, tr_auc = train_one_epoch(model, train_loader)
    val_loss, val_auc = validate(model, val_loader)
    scheduler.step()
    elapsed = time.time() - start

    print(f"[Epoch {epoch}/{max_epochs}] "
          f"time={elapsed:.1f}s | "
          f"train_loss={tr_loss:.4f}, train_auc={tr_auc:.4f} | "
          f"val_loss={val_loss:.4f}, val_auc={val_auc:.4f}")

    if val_auc > best_auc:
        best_auc = val_auc
        epochs_no_improve = 0
        torch.save(model.state_dict(), "best_resnet50_full.pt")
    else:
        epochs_no_improve += 1
        if epochs_no_improve > patience:
            print(f"No improvement for {patience} epochs—stopping early.")
            break

print(f"Best full-data val_auc: {best_auc:.4f}")

[Epoch 1/15] time=1021.3s | train_loss=0.2816, train_auc=0.9508 | val_loss=0.1940, val_auc=0.9762
[Epoch 2/15] time=997.6s | train_loss=0.2223, train_auc=0.9693 | val_loss=0.1773, val_auc=0.9801
[Epoch 3/15] time=969.1s | train_loss=0.2053, train_auc=0.9737 | val_loss=0.1543, val_auc=0.9837
[Epoch 4/15] time=963.4s | train_loss=0.1936, train_auc=0.9765 | val_loss=0.1494, val_auc=0.9847
[Epoch 5/15] time=958.1s | train_loss=0.1905, train_auc=0.9773 | val_loss=0.1483, val_auc=0.9847
[Epoch 6/15] time=953.9s | train_loss=0.1868, train_auc=0.9781 | val_loss=0.1495, val_auc=0.9844
[Epoch 7/15] time=954.8s | train_loss=0.1845, train_auc=0.9789 | val_loss=0.1472, val_auc=0.9849
[Epoch 8/15] time=968.2s | train_loss=0.1867, train_auc=0.9782 | val_loss=0.1458, val_auc=0.9854
[Epoch 9/15] time=961.6s | train_loss=0.1821, train_auc=0.9793 | val_loss=0.1438, val_auc=0.9857
[Epoch 10/15] time=968.6s | train_loss=0.1793, train_auc=0.9798 | val_loss=0.1381, val_auc=0.9869
[Epoch 11/15] time=956.4s | train_loss=0.1711, train_auc=0.9818 | val_loss=0.1365, val_auc=0.9877
[Epoch 12/15] time=957.2s | train_loss=0.1623, train_auc=0.9835 | val_loss=0.1277, val_auc=0.9887
[Epoch 13/15] time=962.1s | train_loss=0.1564, train_auc=0.9846 | val_loss=0.1250, val_auc=0.9892
[Epoch 14/15] time=962.0s | train_loss=0.1484, train_auc=0.9860 | val_loss=0.1218, val_auc=0.9895
[Epoch 15/15] time=959.2s | train_loss=0.1419, train_auc=0.9873 | val_loss=0.1194, val_auc=0.9899
Best full-data val_auc: 0.9899

Observations

• Per-epoch time on this GPU instance is consistently around 960–1020 s (16–17 min).
• Training behavior
  • Starts at train_auc ≈ 0.9508 → ends at train_auc ≈ 0.9873.
  • Steady decrease in train_loss from ~0.28 → ~0.14.
• Validation performance
  • Starts at val_auc ≈ 0.9762 → peaks at 0.9899 on epoch 15.
  • val_loss steadily declines from ~0.19 → ~0.12.
• Early stopping
  • Although we allowed up to 15 epochs, val_auc continued to improve through the end—no early stop was triggered.

With this strong final val AUC (~0.99) and well-behaved losses, it’s time to move on to Section 4: Results & Analysis where we will:

1. Plot learning curves (train & val loss / AUC over epochs)
2. Compare BaselineCNN vs ResNet50 training trajectories
3. Inspect error cases—visualize a few false positives and false negatives
4. Summarize insights and next steps

4. Results & Analysis

4.1 Learning Curves

• Loss steadily decreases for both train and validation sets, with validation loss dropping from ~0.19 → ~0.12 over 15 epochs.
• AUC rises smoothly, with validation AUC improving from ~0.976 → ~0.990 by the final epoch.
• The curves show no catastrophic divergence, indicating stable training and no severe overfitting through epoch 15.

# Manually entered training history from 15-epoch run
history = {
    'train_loss': [
        0.2816, 0.2223, 0.2053, 0.1936, 0.1905,
        0.1868, 0.1845, 0.1867, 0.1821, 0.1793,
        0.1711, 0.1623, 0.1564, 0.1484, 0.1419
    ],
    'val_loss': [
        0.1940, 0.1773, 0.1543, 0.1494, 0.1483,
        0.1495, 0.1472, 0.1458, 0.1438, 0.1381,
        0.1365, 0.1277, 0.1250, 0.1218, 0.1194
    ],
    'train_auc': [
        0.9508, 0.9693, 0.9737, 0.9765, 0.9773,
        0.9781, 0.9789, 0.9782, 0.9793, 0.9798,
        0.9818, 0.9835, 0.9846, 0.9860, 0.9873
    ],
    'val_auc': [
        0.9762, 0.9801, 0.9837, 0.9847, 0.9847,
        0.9844, 0.9849, 0.9854, 0.9857, 0.9869,
        0.9877, 0.9887, 0.9892, 0.9895, 0.9899
    ]
}

epochs = list(range(1, len(history['train_loss']) + 1))

# Plot Loss curves
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.plot(epochs, history['train_loss'], label='Train Loss')
plt.plot(epochs, history['val_loss'],   label='Val Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training & Validation Loss')
plt.legend()

# Plot AUC curves
plt.subplot(1, 2, 2)
plt.plot(epochs, history['train_auc'], label='Train AUC')
plt.plot(epochs, history['val_auc'],   label='Val AUC')
plt.xlabel('Epoch')
plt.ylabel('AUC')
plt.title('Training & Validation AUC')
plt.legend()

plt.tight_layout()
plt.show()

Observations (Loss & AUC Curves)

• Rapid initial gain: Validation AUC jumps from ~0.976 at epoch 1 to ~0.985 by epoch 3, reflecting the power of pre-trained features.
• Smooth convergence: After epoch 3, both train and val AUC continue to inch upward, reaching ~0.990 by epoch 15.
• Well-behaved losses: Training loss steadily declines from ~0.28 → 0.14 and validation loss from ~0.19 → 0.12, with no sharp divergence—indicating minimal overfitting.
• Gap closing: The train/val AUC gap narrows over time, suggesting the model is generalizing nicely.

---

4.2 Baseline vs Transfer-Learning Comparison

Next, let’s directly compare the validation AUC curves of our small BaselineCNN (from Section 3.4) against the ResNet50 transfer model (from Section 3.6).

# Manually entered debug histories
baseline_val_auc = [0.8259, 0.8535, 0.8627, 0.8479, 0.8427,
                    0.8488, 0.8413, 0.8347, 0.8232, 0.8512]
resnet_val_auc   = [0.9762, 0.9801, 0.9837, 0.9847, 0.9847,
                    0.9844, 0.9849, 0.9854, 0.9857, 0.9869,
                    0.9877, 0.9887, 0.9892, 0.9895, 0.9899]

plt.figure(figsize=(6,4))
plt.plot(range(1, len(baseline_val_auc)+1), baseline_val_auc,
         '--o', label='BaselineCNN Val AUC')
plt.plot(range(1, len(resnet_val_auc)+1),   resnet_val_auc,
         '-o',  label='ResNet50 Val AUC')
plt.xlabel('Epoch')
plt.ylabel('Val AUC')
plt.title('Baseline vs Transfer Learning (Val AUC)')
plt.legend()
plt.tight_layout()
plt.show()

• BaselineCNN (10 epochs on debug set) peaks at ~0.8627.
• ResNet50 transfer model (15 epochs full run) soars to ~0.9899.
• The transfer-learning approach clearly outperforms the small CNN by ~0.13 AUC, underscoring the value of pretrained features for histopathology patch classification.

4.3 Error Case Inspection

To better understand where our model still makes mistakes, we’ll surface a handful of false positives and false negatives from the validation set. This can reveal systematic biases (e.g. confusing background tissue for tumor) or edge‐cases (poorly stained patches, extreme color shifts).

model.eval()
errors = []

# Collect up to 8 misclassified patches
with torch.no_grad():
    for imgs, labels in val_loader:
        imgs = imgs.to(device, non_blocking=True)
        labels = labels.to(device, non_blocking=True).long()
        probs = model(imgs).view(-1).cpu().numpy()
        preds = (probs > 0.5).astype(int)

        for img, pred, true, p in zip(imgs.cpu(), preds, labels.cpu(), probs):
            if pred != true:
                errors.append((img, pred, true, p))
            if len(errors) >= 8:
                break
        if len(errors) >= 8:
            break

# Plot 4 false positives (pred=1,true=0) and 4 false negatives (pred=0,true=1)
fig, axes = plt.subplots(2, 4, figsize=(12,6))
for ax, (img, pred, true, prob) in zip(axes.flatten(), errors):
    # un-normalize for display
    img = img * torch.tensor(STD).view(3,1,1) + torch.tensor(MEAN).view(3,1,1)
    img = img.clamp(0,1).permute(1,2,0).numpy()
    ax.imshow(img)
    ax.set_title(f"pred={pred}, true={true}\np={prob:.2f}")
    ax.axis('off')

plt.suptitle("Validation Misclassifications")
plt.tight_layout(rect=[0,0,1,0.95])
plt.show()

Observations (Validation Misclassifications)

• False Negatives (pred=0, true=1):

  • The model missed tumor in lighter‐stained patches (e.g., very pale background with sparse nuclei) → p≈0.45, 0.47, 0.25.
  • In one case (p≈0.02), the tissue is denser but the stain is washed out, causing the model to under-confidently predict no tumor.

• False Positives (pred=1, true=0):

  • Some benign patches with compact nuclei clusters trick the model into high confidence (p≈0.92, 0.62, 0.59).
  • These appear to be regions of dense connective tissue or inflammatory cells that visually resemble tumor morphology.

• Edge-case patterns:

  • Extremely bright or very dark regions tend to shift the model’s probability toward the wrong class.
  • Background artifacts (large white regions) can either suppress or exaggerate confidence.

Takeaway:

• We should consider targeted augmentations to help the model handle under- and over-exposed patches (e.g., random brightness/contrast extremes).
• Adding a few curated negative examples of dense non-tumor nuclei during training may reduce high-confidence false positives.
• A small post-processing threshold adjustment (e.g., raising decision threshold above 0.5) might improve precision on these edge cases.

4.4 Summary & Next Steps

Summary of Key Findings

• Our ResNet50 transfer‐learning model reached 0.9899 val AUC on the full 80/20 split—far surpassing the small BaselineCNN’s ~0.86.
• Loss and AUC curves showed smooth convergence with no catastrophic overfitting; training and validation metrics tracked closely.
• Error analysis revealed two main failure modes:
  1. False negatives in very pale or under-stained patches
  2. False positives on dense, non-tumor nuclei regions

Next Steps & Improvements

1. Augmentation refinements

   • Add more extreme brightness/contrast jitter to simulate washed-out and over-stained slides.
   • Consider blur/noise augmentations to improve robustness to scanning artifacts.

2. Calibration & threshold tuning

   • Evaluate precision–recall trade-offs and set an optimal decision threshold (e.g. by maximizing F1 or Youden’s J).
   • Calibrate output probabilities (temperature scaling or Platt scaling) for more reliable scores.

3. Data balancing / hard-negative mining

   • Incorporate additional benign patches that mimic tumor appearance to reduce high-confidence false positives.
   • Use the current model to mine hard negatives from unlabeled data (pseudo-labeling) and retrain.

4. Model ensembles & architectures

   • Combine ResNet50 with a second backbone (e.g., EfficientNet or DenseNet) in an ensemble to boost robustness.
   • Experiment with more advanced architectures (attention mechanisms, dual-path networks) for fine-grained histology.

5. Test-time augmentation (TTA)

   • Average predictions over multiple random flips/rotations to reduce variance at inference time.

6. Submission & future evaluation

   • Generate final predictions on the held-out test set and submit to Kaggle to gauge leaderboard performance.
   • Explore explainability tools (Grad-CAM) to visualize model focus and validate against pathologist insights.

With these steps, we can further tighten performance, reduce edge-case errors, and build a robust pipeline ready for real-world histopathology classification.

5. Conclusion

In this project, we tackled the binary classification of histopathology image patches to detect metastatic cancer. Our end-to-end pipeline included:

What we built

• Looked at the data first.
  We checked class balance (~130k negative vs ~89k positive), computed per-channel mean/std, normalized images, and used flips/rotations and gentle color jitter to mimic staining differences.

• Started simple, then leveled up.
  A small CNN gave us a solid baseline (~0.86 AUC). Switching to ResNet-50 (pretrained), keeping most layers frozen and adding a small sigmoid head, jumped to ~0.90 AUC in a handful of epochs. After that, fine-tuning layer4 with a two-LR Adam, cosine schedule, and a light weight decay (1e-4) pushed things further.

• Scaled it up.
  On the full 80/20 split (bs=64, class-weighted sampling, mixed precision), the model reached 0.9899 validation AUC in ~15 epochs, with smooth loss/AUC curves.

Where it still trips

• False negatives on patches that are under- or over-stained.
• False positives on regions with dense, non-tumor nuclei that “look” malignant to the model.

What mattered most

• Transfer learning with ResNet-50 was the biggest win.
• Good normalization + color/brightness jitter made the model sturdier to staining/scan variation.
• Cosine LR + tuned weight decay nudged us to a higher peak AUC.
• Weighted sampling helped counter the class imbalance.

What we’d try next

• Richer augmentations: include stronger brightness/contrast shifts and blur to mimic scanner artifacts.
• Threshold & calibration: pick operating points from PR curves and calibrate probabilities.
• Hard-negative mining: feed the model its most confusing non-tumor patches.
• Ensembles: mix backbones (EfficientNet, DenseNet) for extra robustness.
• Explainability & scaling up: use Grad-CAM to verify attention and explore aggregating patch predictions to slide-level decisions.

Bottom line: by moving deliberately—EDA → baselines → targeted improvements → careful validation—we ended up with a high-performing, understandable model that’s ready to be pushed toward real clinical workflows.

---

GitHub Respo: https://github.com/vinahuyen/Histopathologic_Cancer_Detection.git

---